home *** CD-ROM | disk | FTP | other *** search
/ Power DOS 1996 July / Power DOS - July 1996.iso / sound / c_labs / awe / adip.exe / ADIP02.ZIP / WINDOWS / SAMPLE / WINAWE32.C < prev    next >
C/C++ Source or Header  |  1994-07-08  |  22KB  |  763 lines
  1. /*****************************************************************************
  2. *                                         *
  3. * WINAWE32 Sample demo for Sound Blaster Advanced WavEffects             *
  4. *                                         *
  5. * (C) Copyright Creative Technology Ltd. 1992-94. All rights reserved         *
  6. * worldwide.                                     *
  7. *                                         *
  8. * THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY      *
  9. * KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE         *
  10. * IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR      *
  11. * PURPOSE.                                     *
  12. *                                         *
  13. * You have a royalty-free right to use, modify, reproduce and             *
  14. * distribute the Sample Files (and/or any modified version) in             *
  15. * any way you find useful, provided that you agree to                 *
  16. * the Creative's Software Licensing Aggreement and you also agree that       *
  17. * Creative has no warranty obligations or liability for any Sample Files.    *
  18. *                                         *
  19. ******************************************************************************/
  20. /*****************************************************************************\
  21. *    File name     : WINAWE32.C                             *
  22. *                                         *
  23. *    Programmer  : Cheng Kok Hoong                         *
  24. *           Creative Technology Ltd, 1994. All rights reserved.         *
  25. *                                                                            *
  26. *    Version     : 1.1.1                                                     *
  27. *                                                                            *
  28. *    WINAWE32 is a sample application that uses SB AWE32's AWEMAN.DLL        *
  29. *    and AWEGUI.DLL                                 *
  30. *                                         *
  31. ******************************************************************************/
  32.  
  33. #include "windows.h"
  34. #include "mmsystem.h"
  35. #include "winawe32.h"
  36. #include "awe_dll.h"
  37. #include "awe_api.h"
  38. #include "mci.h"
  39. #include "commdlg.h"
  40. #include "string.h"
  41.  
  42. BOOL InitAWEDLL(void);
  43. BOOL OpenAWEMAN(void);
  44. BOOL CloseAWEMAN(void);
  45. BOOL FetchMIDIFile(HWND);
  46. BOOL FetchUserBankFile(HWND);
  47. void SetReverb(WORD);
  48. void SetChorus(WORD);
  49.  
  50. BOOL bIsMIDIPlaying    = FALSE;
  51. BOOL bIsUserBankLoaded    = FALSE;
  52.  
  53. typedef LRESULT (FAR PASCAL *LPCONTROLPANEL)(LPCSTR, BOOL);
  54. typedef LRESULT (FAR PASCAL *LPCONTROLLERBOB)(LPCSTR, BOOL);
  55.  
  56. LPCONTROLPANEL        lpControlPanel  = NULL;
  57. LPCONTROLLERBOB     lpControllerBob = NULL;
  58. LPFNAWEMANAGER        lpAWEManager    = NULL;
  59.  
  60. HANDLE hInst;
  61. HANDLE            hAWEGUIDLL        = NULL;
  62. HANDLE            hAWEMANDLL        = NULL;
  63. AWEHANDLE        hAWEHandle        = NULL;
  64.  
  65. WORD            wMCIDeviceID    = 0;
  66.  
  67. HWND            hWndDemo        = NULL;
  68.  
  69. char            szFileName[128];
  70. char            szBareName[12];
  71. char            szUserBankName[128];
  72.  
  73. HMIDIOUT        hMIDIOut;
  74.  
  75. #define USER_BANK_NUM        1
  76.  
  77. int PASCAL WinMain(HANDLE hInstance,
  78.            HANDLE hPrevInstance,
  79.            LPSTR  lpCmdLine,
  80.            int      nCmdShow)
  81. {
  82.     MSG     msg;
  83.  
  84.     if (hPrevInstance)
  85.     return FALSE;
  86.     else
  87.     if (!InitApplication(hInstance))
  88.         return (FALSE);
  89.  
  90.     if (!InitInstance(hInstance, nCmdShow))
  91.     return (FALSE);
  92.  
  93.     if (!InitAWEDLL() )
  94.     return FALSE;
  95.  
  96.     if ( !OpenAWEMAN() ) {
  97.     MessageBox(NULL, "Unable to open AWEMAN\0", "Error\0", MB_OK|MB_ICONHAND);
  98.     return FALSE;
  99.     }
  100.  
  101.     while (GetMessage(&msg, NULL, NULL, NULL) ) {
  102.     TranslateMessage(&msg);
  103.     DispatchMessage(&msg);
  104.     }
  105.     return (msg.wParam);
  106. }
  107.  
  108.  
  109. BOOL InitApplication(HANDLE hInstance)
  110. {
  111.     WNDCLASS  wc;
  112.  
  113.     wc.style = NULL;
  114.     wc.lpfnWndProc = MainWndProc;
  115.     wc.cbClsExtra = 0;
  116.     wc.cbWndExtra = 0;
  117.     wc.hInstance = hInstance;
  118.     wc.hIcon = LoadIcon(hInstance, (LPCSTR)IDI_ICON1);
  119.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  120.     wc.hbrBackground = GetStockObject(WHITE_BRUSH);
  121.     wc.lpszMenuName =  "WinAWE32Menu";
  122.     wc.lpszClassName = "WinAWE32Class";
  123.  
  124.     return (RegisterClass(&wc));
  125.  
  126. }
  127.  
  128.  
  129. BOOL InitInstance(HANDLE hInstance, int nCmdShow)
  130. {
  131.     HWND        hWnd;
  132.     RECT        rectWindow;
  133.  
  134.     hInst = hInstance;
  135.  
  136.     hWnd = CreateWindow(
  137.     "WinAWE32Class",
  138.     "WinAWE32 Sample Demo",
  139.     WS_OVERLAPPEDWINDOW,
  140.     CW_USEDEFAULT,
  141.     CW_USEDEFAULT,
  142.     CW_USEDEFAULT,
  143.     CW_USEDEFAULT,
  144.     NULL,
  145.     NULL,
  146.     hInstance,
  147.     NULL
  148.     );
  149.  
  150.     if (!hWnd)
  151.     return (FALSE);
  152.  
  153.     // Resize the Window
  154.     #define WIN_WIDTH    400
  155.     #define WIN_HEIGHT    100
  156.  
  157.     GetWindowRect(hWnd, &rectWindow);
  158.     MoveWindow(hWnd, rectWindow.left, rectWindow.top, WIN_WIDTH, WIN_HEIGHT, TRUE);
  159.     ShowWindow(hWnd, nCmdShow);
  160.     hWndDemo = hWnd;
  161.  
  162.     return (TRUE);
  163.  
  164. }
  165.  
  166. long CALLBACK __export MainWndProc(HWND     hWnd,
  167.                    UINT     message,
  168.                    WPARAM   wParam,
  169.                    LPARAM   lParam)
  170. {
  171.     CParamObject cObject;
  172.     CBufferObject cBufferObj;
  173.     DWORD     dwMaxDRAM, dwAvailableDRAM;
  174.     char     ach[128];
  175.     HCURSOR     hCursor;
  176.  
  177.     cObject.m_SBankIndex    = 0;
  178.     cObject.m_UBankIndex    = 0;
  179.     cObject.m_InstrIndex    = 0;
  180.     cObject.m_TypeIndex     = REVERB_CHORUS;
  181.     cObject.m_SubIndex        = REVERB;
  182.  
  183.     switch (message)
  184.     {
  185.     case WM_COMMAND: {
  186.         switch ( wParam ) {
  187.         case ID_CLEAR_BANK: {
  188.             if ( bIsUserBankLoaded == TRUE ) {
  189.             if ( lpAWEManager(hAWEHandle, AWE_CLEAR_USER_BANK, USER_BANK_NUM, NULL) != AWE_NO_ERR )
  190.                 MessageBox(NULL, "Error clearing user bank\0", "Error\0", MB_OK|MB_ICONHAND);
  191.             else {
  192.                 MessageBox(NULL, "User Bank 1 unloaded\0", "Info\0", MB_OK);
  193.                 bIsUserBankLoaded = FALSE;
  194.             }
  195.             }
  196.         }
  197.         break;
  198.  
  199.         case ID_STOP_MIDI:
  200.             if ( bIsMIDIPlaying == TRUE ) {
  201.             if ( MCIEndPlay(wMCIDeviceID) )
  202.                 MessageBox(NULL, "Error stop playing MCISEQ.\0", "Error.\0", MB_OK|MB_ICONSTOP);
  203.             if ( MCICloseDevice(wMCIDeviceID) )
  204.                 MessageBox(NULL, "Error closing MCISEQ.\0", "Error.\0", MB_OK|MB_ICONSTOP);
  205.             bIsMIDIPlaying = FALSE;
  206.             }
  207.             break;
  208.  
  209.         case ID_LOAD_USERBANK:
  210.             if ( FetchUserBankFile(hWnd) ) {
  211.             // Now load the bank into user bank 1... not enough
  212.             // time to do a flexible user bank dialog box
  213.             cBufferObj.m_Size = 128;    // Size of string buffer
  214.             cBufferObj.m_Flag = OPER_FILE;
  215.             cBufferObj.m_Buffer = (LPSTR)szUserBankName;
  216.  
  217.             hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
  218.  
  219.             if ( lpAWEManager(hAWEHandle,
  220.                   AWE_LOAD_USER_BANK,
  221.                   (LPARAM)USER_BANK_NUM,
  222.                   (LPARAM)(LPSTR)&cBufferObj) == AWE_NO_ERR ) {
  223.                 MessageBox(NULL, "User Bank 1 load successful\0",
  224.                      "Info\0",
  225.                      MB_OK);
  226.                 bIsUserBankLoaded = TRUE;
  227.             }
  228.             else {
  229.                 MessageBox(NULL, "User Bank load failed.\0",
  230.                      "Error\0",
  231.                      MB_OK);
  232.             }
  233.             SetCursor(hCursor);
  234.             }
  235.             break;
  236.  
  237.         case ID_SETTINGS_TRIGGERME:
  238.             DialogBox(hInst,        /* current instance      */
  239.             "TriggerMe",        /* resource to use           */
  240.             hWnd,            /* parent handle         */
  241.             TriggerMe);        /* About() instance address  */
  242.  
  243.         break;
  244.  
  245.         case ID_FILE_OPEN:
  246.             if ( FetchMIDIFile(hWnd) ) {
  247.             if ( bIsMIDIPlaying == TRUE ) {
  248.                 MCIEndPlay(wMCIDeviceID);
  249.                 MCICloseDevice(wMCIDeviceID);
  250.             }
  251.             if ( MCIOpenDevice(&wMCIDeviceID, szFileName) ) {
  252.                 MessageBox(NULL, "Error in opening MCI.\0", "Error\0", MB_OK|MB_ICONSTOP);
  253.                 break;
  254.             }
  255.             else {
  256.                 MCIPlayDevice(hWnd, wMCIDeviceID);
  257.                 bIsMIDIPlaying = TRUE;
  258.                 // Update main windows's title to reflect the currently playing MIDI file
  259.                 SetWindowText(hWnd, szBareName);
  260.             }
  261.             }
  262.             break;
  263.  
  264.         case ID_QUIT:
  265.             PostMessage(hWnd, WM_DESTROY, NULL, NULL); break;
  266.  
  267.         case IDM_ABOUT:
  268.             DialogBox(hInst,        /* current instance      */
  269.             "AboutBox",         /* resource to use           */
  270.             hWnd,            /* parent handle         */
  271.             About);         /* About() instance address  */
  272.  
  273.         break;
  274.  
  275.         case ID_QUERY_SYNTH: {
  276.             CBufferObject   buffer;
  277.             char        voila;
  278.             enum SBANK        sBank;
  279.  
  280.             buffer.m_Size   = sizeof(voila);
  281.             buffer.m_Buffer = (LPSTR)&voila;
  282.             lpAWEManager(hAWEHandle,
  283.                  AWE_GET_SYN_BANK,
  284.                  (LPARAM)(LPBUFFEROBJECT)&buffer,
  285.                  0L);
  286.  
  287.             sBank = (enum SBANK)buffer.m_Flag;
  288.  
  289.             if ( sBank == GENERAL_MIDI )
  290.             MessageBox(NULL, "Current synthesizer mode is General MIDI\0",
  291.                      "Info\0",
  292.                      MB_OK);
  293.             if ( sBank == ROLAND_GS )
  294.             MessageBox(NULL, "Current synthesizer mode is GS\0",
  295.                      "Info\0",
  296.                      MB_OK);
  297.             if ( sBank == MT_32 )
  298.             MessageBox(NULL, "Current synthesizer mode is MT-32\0",
  299.                      "Info\0",
  300.                      MB_OK);
  301.         }
  302.         break;
  303.  
  304.         case ID_QUERY_DRAM:
  305.             if ( lpAWEManager(hAWEHandle,
  306.                       AWE_QUERY_DRAM_SIZE,
  307.                       (LPARAM)(LPSTR)&dwMaxDRAM,
  308.                       (LPARAM)(LPSTR)&dwAvailableDRAM) == AWE_NO_ERR ) {
  309.  
  310.             (void)wsprintf(ach, "TotalDRAM = %lu bytes, AvailableDRAM = %lu bytes\0", dwMaxDRAM*2, dwAvailableDRAM*2);
  311.             MessageBox(NULL, ach, "DRAM Info\0", MB_OK);
  312.             }
  313.         break;
  314.  
  315.  
  316.         case ID_GUI_CONTROLPANEL: {
  317.             LRESULT result = lpControlPanel("Peek-A-Boo !\0", FALSE);
  318.             if ( result != AWE_NO_ERR ) {
  319.             switch ( result ) {
  320.                 case AWE_ERR_DLL_BUSY:
  321.                 MessageBox(NULL, "DLL Busy\0", "Error\0", MB_OK);
  322.                 break;
  323.                 case AWE_ERR_SYSMEM_INSUFFICIENT:
  324.                 MessageBox(NULL,"Insufficient Memory\0", "Error\0", MB_OK);
  325.                 break;
  326.                 case AWE_ERR_ACTIVATE_BOB:
  327.                 MessageBox(NULL,"BOB already activated\0", "Error\0", MB_OK);
  328.                 break;
  329.                 case AWE_ERR_DEVICE_DRV_INVALID:
  330.                 MessageBox(NULL,"Invalid driver\0", "Error\0", MB_OK);
  331.                 break;
  332.             }
  333.             }
  334.             break;
  335.  
  336.         }
  337.  
  338.         case ID_GUI_CONTROLLER: {
  339.             LRESULT result = lpControllerBob("Peek-A-Boo Two !\0", FALSE);
  340.             if ( result != AWE_NO_ERR ) {
  341.             switch ( result ) {
  342.                 case AWE_ERR_DLL_BUSY:
  343.                 MessageBox(NULL,"DLL Busy\0", "Error\0", MB_OK);
  344.                 break;
  345.                 case AWE_ERR_SYSMEM_INSUFFICIENT:
  346.                 MessageBox(NULL,"Insufficient Memory\0", "Error\0", MB_OK);
  347.                 break;
  348.                 case AWE_ERR_ACTIVATE_BOB:
  349.                 MessageBox(NULL,"BOB already activated\0", "Error\0", MB_OK);
  350.                 break;
  351.                 case AWE_ERR_DEVICE_DRV_INVALID:
  352.                 MessageBox(NULL,"Invalid driver\0", "Error\0", MB_OK);
  353.                 break;
  354.             }
  355.             }
  356.             break;
  357.  
  358.         }
  359.  
  360.         case ID_MISC_SYNTHBANK_GM:
  361.             hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
  362.             if ( lpAWEManager(hAWEHandle, AWE_SELECT_SYN_BANK, GENERAL_MIDI, NULL) == AWE_NO_ERR )
  363.             MessageBox(NULL, "Set synthesizer mode to General MIDI successful.\0", "Info\0", MB_OK);
  364.             else
  365.             MessageBox(NULL, "Set GM failed.\0", "Error\0", MB_OK);
  366.             SetCursor(hCursor);
  367.             break;
  368.  
  369.         case ID_MISC_SYNTHBANK_GS:
  370.             hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
  371.             if ( lpAWEManager(hAWEHandle, AWE_SELECT_SYN_BANK, ROLAND_GS, NULL) == AWE_NO_ERR )
  372.             MessageBox(NULL, "Set synthesizer mode to GS successful.\0", "Info\0", MB_OK);
  373.             else
  374.             MessageBox(NULL, "Set GS failed.\0", "Error\0", MB_OK);
  375.             SetCursor(hCursor);
  376.             break;
  377.  
  378.         case ID_MISC_SYNTHBANK_MT32:
  379.             hCursor = SetCursor(LoadCursor(NULL, IDC_WAIT));
  380.             if ( lpAWEManager(hAWEHandle, AWE_SELECT_SYN_BANK, MT_32, NULL) == AWE_NO_ERR )
  381.             MessageBox(NULL, "Set synthesizer mode to MT-32 successful.\0", "Info\0", MB_OK);
  382.             else
  383.             MessageBox(NULL, "Set MT-32 failed.\0", "Error\0", MB_OK);
  384.             SetCursor(hCursor);
  385.             break;
  386.  
  387.         case ID_SETTINGS_REVERB_ROOM1 :
  388.         case ID_SETTINGS_REVERB_ROOM2 :
  389.         case ID_SETTINGS_REVERB_ROOM3 :
  390.         case ID_SETTINGS_REVERB_HALL1 :
  391.         case ID_SETTINGS_REVERB_HALL2 :
  392.         case ID_SETTINGS_REVERB_PLATE :
  393.         case ID_SETTINGS_REVERB_DELAY :
  394.         case ID_SETTINGS_REVERB_PANNINGDELAY :
  395.             SetReverb(wParam);
  396.             break;
  397.  
  398.         case ID_SETTINGS_CHORUS_CHORUS1 :
  399.         case ID_SETTINGS_CHORUS_CHORUS2 :
  400.         case ID_SETTINGS_CHORUS_CHORUS3 :
  401.         case ID_SETTINGS_CHORUS_CHORUS4 :
  402.         case ID_SETTINGS_CHORUS_FEEBACKCHORUS :
  403.         case ID_SETTINGS_CHORUS_FLANGER :
  404.         case ID_SETTINGS_CHORUS_SHORTDELAY :
  405.         case ID_SETTINGS_CHORUS_SHORTDELAYFB :
  406.             SetChorus(wParam);
  407.             break;
  408.         }
  409.         break;
  410.     }
  411.     break;
  412.  
  413.     case WM_DESTROY:
  414.         if ( bIsMIDIPlaying == TRUE ) {
  415.         if ( MCIEndPlay(wMCIDeviceID) )
  416.             MessageBox(NULL, "Error stop playing MCISEQ.\0", "Error.\0", MB_OK|MB_ICONSTOP);
  417.         if ( MCICloseDevice(wMCIDeviceID) )
  418.             MessageBox(NULL, "Error closing MCISEQ.\0", "Error.\0", MB_OK|MB_ICONSTOP);
  419.         }
  420.  
  421.         if ( bIsUserBankLoaded == TRUE ) {
  422.         if ( lpAWEManager(hAWEHandle, AWE_CLEAR_USER_BANK, USER_BANK_NUM, NULL) != AWE_NO_ERR )
  423.             MessageBox(NULL, "Error clearing user bank\0", "Error\0", MB_OK|MB_ICONHAND);
  424.         }
  425.  
  426.         if ( CloseAWEMAN() == FALSE )
  427.         MessageBox(NULL, "Error closing AWEMAN\0", "Error", MB_OK|MB_ICONSTOP);
  428.  
  429.         FreeLibrary(hAWEMANDLL);
  430.         FreeLibrary(hAWEGUIDLL);
  431.  
  432.         PostQuitMessage(0);
  433.         break;
  434.  
  435.     default:
  436.         return (DefWindowProc(hWnd, message, wParam, lParam));
  437.     }
  438.     return (NULL);
  439. }
  440.  
  441.  
  442. BOOL __export CALLBACK About(HWND    hDlg,
  443.                  unsigned    message,
  444.                  WORD    wParam,
  445.                  LPARAM    lParam)
  446. {
  447.     switch (message)
  448.     {
  449.     case WM_INITDIALOG:
  450.         return (TRUE);
  451.  
  452.     case WM_COMMAND:
  453.         if (wParam == IDOK
  454.         || wParam == IDCANCEL)
  455.         {
  456.         EndDialog(hDlg, TRUE);
  457.         return (TRUE);
  458.         }
  459.         break;
  460.     }
  461.     return (FALSE);
  462. }
  463.  
  464. BOOL __export CALLBACK TriggerMe(HWND        hDlg,
  465.                  unsigned   message,
  466.                  WORD        wParam,
  467.                  LPARAM     lParam)
  468. {
  469.  
  470.     #define BIG_ON    0x007F3C90
  471.     #define BIG_OFF    0x00003C90
  472.     #define PATCH_SET    0x00007FC0
  473.  
  474.     DWORD   dwErr;
  475.     char    ach[128];
  476.     DWORD   dwPresetNumber;
  477.     static DWORD   dwMIDINumber = 0xF;
  478.     BOOL    fTranslated;
  479.  
  480.     switch (message)
  481.     {
  482.     case WM_INITDIALOG:
  483.         // Set to preset 1 on startup, MIDI channel 16
  484.         SetDlgItemInt(hDlg, IDC_PC, 0x0, FALSE);
  485.         SetDlgItemInt(hDlg, IDC_MIDI, 0xF, FALSE);
  486.         return (TRUE);
  487.  
  488.     case WM_COMMAND:
  489.         switch ( wParam ) {
  490.         case IDOK:
  491.             EndDialog(hDlg, TRUE);
  492.             return TRUE;
  493.  
  494.         case IDC_BIGON:
  495.             dwErr = lpAWEManager(hAWEHandle, AWE_SEND_MIDI, BIG_ON+dwMIDINumber, NULL);
  496.             if ( dwErr != AWE_NO_ERR ) {
  497.             (void)wsprintf(ach, "Error code = %d\0", (WORD)dwErr);
  498.             MessageBox(NULL, ach, "Error\0", MB_OK|MB_ICONSTOP);
  499.             }
  500.             return TRUE;
  501.  
  502.         case IDC_BIGOFF:
  503.             dwErr = lpAWEManager(hAWEHandle, AWE_SEND_MIDI, BIG_OFF+dwMIDINumber, NULL);
  504.             if ( dwErr != AWE_NO_ERR ) {
  505.             (void)wsprintf(ach, "Error code = %d\0", (WORD)dwErr);
  506.             MessageBox(NULL, ach, "Error\0", MB_OK|MB_ICONSTOP);
  507.             }
  508.             return TRUE;
  509.  
  510.         case IDC_SETPATCH:
  511.             // Get the patch number
  512.             dwPresetNumber = (DWORD)GetDlgItemInt(hDlg, IDC_PC, (BOOL FAR*)&fTranslated, FALSE);
  513.             if ( dwPresetNumber > 0x7F )
  514.             dwPresetNumber = 0x7F;
  515.             dwPresetNumber = (dwPresetNumber << 8) + dwMIDINumber + 0xC0;
  516.  
  517.             dwErr = lpAWEManager(hAWEHandle, AWE_SEND_MIDI, dwPresetNumber, NULL);
  518.             if ( dwErr != AWE_NO_ERR ) {
  519.             (void)wsprintf(ach, "Error code = %d\0", (WORD)dwErr);
  520.             MessageBox(NULL, ach, "Error\0", MB_OK|MB_ICONSTOP);
  521.             }
  522.             return TRUE;
  523.  
  524.         case IDC_SETMIDI:
  525.             // Get the MIDI channel
  526.             dwMIDINumber = (DWORD)GetDlgItemInt(hDlg, IDC_MIDI, (BOOL FAR*)&fTranslated, FALSE);
  527.             if ( dwMIDINumber > 0xF )
  528.             dwMIDINumber = 0xF;
  529.             return TRUE;
  530.         }
  531.         break;
  532.     }
  533.     return (FALSE);
  534. }
  535.  
  536. BOOL InitAWEDLL(void)
  537. {
  538.     hAWEGUIDLL = LoadLibrary("AWEGUI.DLL");
  539.     if ( hAWEGUIDLL > HINSTANCE_ERROR ) {
  540.     lpControlPanel = (LPCONTROLPANEL)GetProcAddress(hAWEGUIDLL, "AWEControlPanel");
  541.     lpControllerBob = (LPCONTROLPANEL)GetProcAddress(hAWEGUIDLL, "AWEControllerBob");
  542.     if ( lpControlPanel == NULL || lpControllerBob == NULL )
  543.         return FALSE;
  544.     }
  545.     hAWEMANDLL = LoadLibrary("AWEMAN.DLL");
  546.     if ( hAWEGUIDLL > HINSTANCE_ERROR ) {
  547.     lpAWEManager = (LPFNAWEMANAGER)GetProcAddress(hAWEMANDLL, "AWEManager");
  548.     if ( lpAWEManager == NULL)
  549.         return FALSE;
  550.     }
  551.     return TRUE;
  552. }
  553.  
  554.  
  555. BOOL OpenAWEMAN()
  556. {
  557.     if ( lpAWEManager(NULL, AWE_OPEN, (LPARAM)(LPSTR)&hAWEHandle, NULL) == AWE_NO_ERR )
  558.     return TRUE;
  559.     else
  560.     return FALSE;
  561. }
  562.  
  563.  
  564. BOOL CloseAWEMAN()
  565. {
  566.     if ( lpAWEManager(hAWEHandle, AWE_CLOSE, NULL, NULL ) == AWE_NO_ERR )
  567.     return TRUE;
  568.     else
  569.     return FALSE;
  570. }
  571.  
  572.  
  573. BOOL FetchMIDIFile(HWND hWnd)
  574. {
  575.  
  576.     char        szMIDIExt[] = "MIDI\0*.MID; *.RMI\0";
  577.     WORD        wReturnVal = 0;
  578.     DWORD        dwErrorVal = 0;
  579.     OPENFILENAME    ofnMIDI;
  580.     // char           szInitFile[128]
  581.  
  582.     strcpy(szFileName, szBareName);
  583.  
  584.     // szFileName[0] = 0;
  585.  
  586.     ofnMIDI.lStructSize         = sizeof(OPENFILENAME);
  587.     ofnMIDI.hwndOwner            = hWnd;
  588.     ofnMIDI.hInstance            = hInst;
  589.     ofnMIDI.lpstrFilter         = szMIDIExt;
  590.     ofnMIDI.lpstrCustomFilter        = NULL;
  591.     ofnMIDI.nMaxCustFilter        = 0L;
  592.     ofnMIDI.nFilterIndex        = 1L;
  593.     ofnMIDI.lpstrFile            = (LPSTR)szFileName;
  594.     ofnMIDI.nMaxFile            = 128;
  595.     ofnMIDI.lpstrInitialDir        = NULL;
  596.     ofnMIDI.lpstrTitle            = NULL;
  597.     ofnMIDI.lpstrFileTitle        = (LPSTR)szBareName;
  598.     ofnMIDI.lpstrDefExt         = NULL;
  599.     ofnMIDI.Flags            = 0;
  600.  
  601.     wReturnVal = GetOpenFileName((LPOPENFILENAME)&ofnMIDI);
  602.     if ( wReturnVal > 0 )
  603.      return TRUE;
  604.     else
  605.     return FALSE;
  606.  
  607. }
  608.  
  609. BOOL FetchUserBankFile(HWND hWnd)
  610. {
  611.  
  612.     char        szSBKExt[] = "SoundFont Bank\0*.SBK\0";
  613.     WORD        wReturnVal = 0;
  614.     DWORD        dwErrorVal = 0;
  615.     OPENFILENAME    ofnSBK;
  616.  
  617.     ofnSBK.lStructSize               = sizeof(OPENFILENAME);
  618.     ofnSBK.hwndOwner               = hWnd;
  619.     ofnSBK.hInstance               = hInst;
  620.     ofnSBK.lpstrFilter               = szSBKExt;
  621.     ofnSBK.lpstrCustomFilter           = NULL;
  622.     ofnSBK.nMaxCustFilter           = 0L;
  623.     ofnSBK.nFilterIndex            = 1L;
  624.     ofnSBK.lpstrFile               = (LPSTR)szUserBankName;
  625.     ofnSBK.nMaxFile               = 128;
  626.     ofnSBK.lpstrInitialDir           = NULL;
  627.     ofnSBK.lpstrTitle               = NULL;
  628.     ofnSBK.lpstrFileTitle           = NULL;
  629.     ofnSBK.lpstrDefExt               = NULL;
  630.     ofnSBK.Flags               = 0;
  631.  
  632.     wReturnVal = GetOpenFileName((LPOPENFILENAME)&ofnSBK);
  633.     if ( wReturnVal > 0 )
  634.      return TRUE;
  635.     else
  636.     return FALSE;
  637.  
  638. }
  639.  
  640. void SetReverb(WORD wParam)
  641. {
  642.  
  643.     CParamObject     param;
  644.     enum TYPEINDEX     m_CurEfxType;
  645.     enum VARIINDEX     m_CurTypeVari[2];
  646.  
  647.     param.m_VariIndex[REVERB] = param.m_VariIndex[CHORUS] = 0;
  648.  
  649.     lpAWEManager(hAWEHandle, AWE_GET_EFX, (LPARAM)(LPSTR)¶m, (LPARAM)0L);
  650.     m_CurEfxType = (enum TYPEINDEX)param.m_TypeIndex;
  651.  
  652.     if ( m_CurEfxType == REVERB_CHORUS ) {
  653.     // Correct !
  654.     m_CurTypeVari[REVERB] = (enum VARIINDEX)param.m_VariIndex[REVERB];
  655.     m_CurTypeVari[CHORUS] = (enum VARIINDEX)param.m_VariIndex[CHORUS];
  656.  
  657.     // Now issue selection on REVERB
  658.     switch ( wParam ) {
  659.         case ID_SETTINGS_REVERB_ROOM1 :
  660.         param.m_VariIndex[REVERB] = (enum VARIINDEX)ROOM_1; break;
  661.  
  662.         case ID_SETTINGS_REVERB_ROOM2 :
  663.         param.m_VariIndex[REVERB] = (enum VARIINDEX)ROOM_2; break;
  664.  
  665.         case ID_SETTINGS_REVERB_ROOM3 :
  666.         param.m_VariIndex[REVERB] = (enum VARIINDEX)ROOM_3; break;
  667.  
  668.         case ID_SETTINGS_REVERB_HALL1 :
  669.         param.m_VariIndex[REVERB] = (enum VARIINDEX)HALL_1; break;
  670.  
  671.         case ID_SETTINGS_REVERB_HALL2 :
  672.         param.m_VariIndex[REVERB] = (enum VARIINDEX)HALL_2; break;
  673.  
  674.         case ID_SETTINGS_REVERB_PLATE :
  675.         param.m_VariIndex[REVERB] = (enum VARIINDEX)PLATE; break;
  676.  
  677.         case ID_SETTINGS_REVERB_DELAY :
  678.         param.m_VariIndex[REVERB] = (enum VARIINDEX)DELAY; break;
  679.  
  680.         case ID_SETTINGS_REVERB_PANNINGDELAY :
  681.         param.m_VariIndex[REVERB] = (enum VARIINDEX)PANNING_DELAY; break;
  682.     }
  683.     if ( lpAWEManager(hAWEHandle, AWE_SELECT_EFX, (LPARAM)(LPSTR)¶m, (LPARAM)0L) != AWE_NO_ERR ) {
  684.         MessageBox(NULL, "Error in setting effect.\0",
  685.                  "Error\0",
  686.                  MB_OK|MB_ICONSTOP);
  687.     }
  688.     else {
  689.         MessageBox(NULL, "Effect setting successful.\0",
  690.                  "OK !\0",
  691.                  MB_OK|MB_ICONINFORMATION);
  692.     }
  693.     }
  694.     else {
  695.     MessageBox(NULL, "Current effect type is not Reverb/Chorus.\0",
  696.              "Error\0",
  697.              MB_OK|MB_ICONSTOP);
  698.     }
  699. }
  700.  
  701.  
  702. void SetChorus(WORD wParam)
  703. {
  704.     CParamObject     param;
  705.     enum TYPEINDEX     m_CurEfxType;
  706.     enum VARIINDEX     m_CurTypeVari[2];
  707.  
  708.     param.m_VariIndex[REVERB] = param.m_VariIndex[CHORUS] = 0;
  709.  
  710.     lpAWEManager(hAWEHandle, AWE_GET_EFX, (LPARAM)(LPSTR)¶m, 0L);
  711.     m_CurEfxType = (enum TYPEINDEX)param.m_TypeIndex;
  712.  
  713.     if ( m_CurEfxType == REVERB_CHORUS ) {
  714.     // Correct !
  715.     m_CurTypeVari[REVERB] = (enum VARIINDEX)param.m_VariIndex[REVERB];
  716.     m_CurTypeVari[CHORUS] = (enum VARIINDEX)param.m_VariIndex[CHORUS];
  717.  
  718.     // Now issue selection on CHORUS
  719.     switch ( wParam ) {
  720.         case ID_SETTINGS_CHORUS_CHORUS1 :
  721.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_1; break;
  722.  
  723.         case ID_SETTINGS_CHORUS_CHORUS2 :
  724.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_2; break;
  725.  
  726.         case ID_SETTINGS_CHORUS_CHORUS3 :
  727.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_3; break;
  728.  
  729.         case ID_SETTINGS_CHORUS_CHORUS4 :
  730.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)CHORUS_4; break;
  731.  
  732.         case ID_SETTINGS_CHORUS_FEEBACKCHORUS :
  733.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)FEEDBACK_DELAY; break;
  734.  
  735.         case ID_SETTINGS_CHORUS_FLANGER :
  736.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)FLANGER; break;
  737.  
  738.         case ID_SETTINGS_CHORUS_SHORTDELAY :
  739.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)SHORT_DELAY; break;
  740.  
  741.         case ID_SETTINGS_CHORUS_SHORTDELAYFB :
  742.         param.m_VariIndex[CHORUS] = (enum VARIINDEX)SHORT_DELAY_FB; break;
  743.  
  744.     }
  745.     if ( lpAWEManager(hAWEHandle, AWE_SELECT_EFX, (LPARAM)(LPSTR)¶m, 0L) != AWE_NO_ERR ) {
  746.         MessageBox(NULL, "Error in setting effect.\0",
  747.                  "Error\0",
  748.                  MB_OK|MB_ICONSTOP);
  749.     }
  750.     else {
  751.         MessageBox(NULL, "Effect setting successful.\0",
  752.                  "OK !\0",
  753.                  MB_OK|MB_ICONINFORMATION);
  754.     }
  755.     }
  756.     else {
  757.     MessageBox(NULL, "Current effect type is not Reverb/Chorus.\0",
  758.              "Error\0",
  759.              MB_OK|MB_ICONSTOP);
  760.     }
  761.  
  762. }
  763.